/**
 * 将颜色调浅一定程度（0-1之间，值越大越浅）
 * @param {string} color - 原始颜色（支持#hex、rgb、rgba格式）
 * @param {number} amount - 调浅程度（默认0.3）
 * @returns {string} 调浅后的颜色
 */
function lightenColor(color, amount = 0.3) {
    // 处理十六进制颜色（#fff 或 #ffffff）
    if (color.startsWith('#')) {
        let hex = color.replace('#', '');
        // 处理3位简写（如#fff → #ffffff）
        if (hex.length === 3) {
            hex = hex.split('').map(c => c + c).join('');
        }

        // 解析RGB值
        const r = parseInt(hex.substring(0, 2), 16);
        const g = parseInt(hex.substring(2, 4), 16);
        const b = parseInt(hex.substring(4, 6), 16);

        // 计算浅一度的RGB（不超过255）
        const lighten = (value) => Math.min(255, Math.round(value + (255 - value) * amount));
        const nr = lighten(r);
        const ng = lighten(g);
        const nb = lighten(b);

        // 转回十六进制
        return `#${((1 << 24) + (nr << 16) + (ng << 8) + nb).toString(16).slice(1)}`;
    }

    // 处理rgb/rgba颜色
    if (color.startsWith('rgb')) {
        const match = color.match(/rgba?\((\d+),\s*(\d+),\s*(\d+)(?:,\s*(\d+(\.\d+)?))?\)/);
        if (match) {
            const r = parseInt(match[1]);
            const g = parseInt(match[2]);
            const b = parseInt(match[3]);
            const alpha = match[4] || 1;

            // 计算浅一度的RGB
            const lighten = (value) => Math.min(255, Math.round(value + (255 - value) * amount));
            const nr = lighten(r);
            const ng = lighten(g);
            const nb = lighten(b);

            // 转回rgb/rgba格式
            return alpha === 1
                ? `rgb(${nr}, ${ng}, ${nb})`
                : `rgba(${nr}, ${ng}, ${nb}, ${alpha})`;
        }
    }

    // 无法解析的颜色返回原始值
    return color;
}
/**
 * 根据开关状态更新渐变样式，保持原始颜色属性不变
 * @param {string|boolean} value - 渐变开关值（'true'/'false'或true/false）
 * @param {Object} currentOptions - 当前图表配置
 * @param {Array} defaultGradients - 默认渐变配置（作为降级方案）
 * @returns {Object} 更新后的配置
 */
function updateGradientStyle(value, currentOptions, defaultGradients) {
    const isGradient = value === 'true' || value === true;
    if (currentOptions.series && Array.isArray(currentOptions.series)) {
        currentOptions.series.forEach((series, index) => {
            if (series.areaStyle) {
                // 保存原始颜色信息（关键：不丢失已有配置）
                const originalColor = series.areaStyle.color;
                const gradientIndex = index % defaultGradients.length;
                const defaultGradient = defaultGradients[gradientIndex];

                // 解析原始颜色，提取基础色（兼容纯色和渐变两种情况）
                let baseStartColor, baseEndColor;

                if (originalColor && originalColor.type === 'linear') {
                    // 原始已是渐变，提取其颜色 stops
                    baseStartColor = originalColor.colorStops?.[0]?.color || defaultGradient.start;
                    baseEndColor = originalColor.colorStops?.[1]?.color || defaultGradient.end;
                } else if (typeof originalColor === 'string') {
                    // 原始是纯色，用该颜色作为基础
                    baseStartColor = originalColor;
                    baseEndColor = lightenColor(originalColor, 0.3); // 浅30%，可调整
                } else {
                    // 无原始颜色时使用默认渐变（降级方案）
                    baseStartColor = defaultGradient.start;
                    baseEndColor = defaultGradient.end;
                }

                // 根据开关状态设置颜色，保持基础色不变
                series.areaStyle.color = isGradient
                    ? new echarts.graphic.LinearGradient(0, 0, 0, 1, [
                        { offset: 0, color: baseStartColor },
                        { offset: 1, color: baseEndColor }
                    ])
                    : baseStartColor; // 关闭渐变时用基础起始色作为纯色
            }
        });
    }
    return currentOptions;
}


/**
 * 更新区域样式显示状态
 * @param {string} value - 是否显示区域，'true'表示显示
 * @param {Object} currentOptions - 当前图表配置选项
 * @param {Array} defaultGradients - 默认渐变颜色配置
 * @returns {Object} 更新后的图表配置选项
 */
function updateAreaStyle(value, currentOptions, defaultGradients) {
    const show = value === 'true';

    if (currentOptions.series && Array.isArray(currentOptions.series)) {
        currentOptions.series.forEach((series, index) => {
            const gradientIndex = index % defaultGradients.length;
            const defaultGradient = defaultGradients[gradientIndex];

            if (show) {
                if (!series.areaStyle) {
                    series.areaStyle = {
                        color: defaultGradient.start
                    };
                }
            } else {
                if (series.areaStyle) {
                    delete series.areaStyle;
                }
            }
        });
    }
    return currentOptions;
}

/**
 * 更新区域颜色
 * @param {string} value - 颜色值
 * @param {Object} currentOptions - 当前图表配置选项
 * @returns {Object} 更新后的图表配置选项
 */
function updateAreaColor(value, currentOptions) {
    if (currentOptions.series && Array.isArray(currentOptions.series)) {
        currentOptions.series.forEach(series => {
            if (series.areaStyle) {
                series.areaStyle.color = value;
            }
        });
    }
    return currentOptions;
}

/**
 * 更新线条平滑度
 * @param {string} value - 是否平滑，'true'表示平滑
 * @param {Object} currentOptions - 当前图表配置选项
 * @returns {Object} 更新后的图表配置选项
 */
function updateSmooth(value, currentOptions) {
    const smooth = value === 'true';
    if (currentOptions.series && Array.isArray(currentOptions.series)) {
        currentOptions.series.forEach(series => {
            series.smooth = smooth;
        });
    }
    return currentOptions;
}

/**
 * 更新线条宽度
 * @param {string|number} value - 线宽值
 * @param {Object} currentOptions - 当前图表配置选项
 * @returns {Object} 更新后的图表配置选项
 */
function updateLineWidth(value, currentOptions) {
    if (currentOptions.series && Array.isArray(currentOptions.series)) {
        currentOptions.series.forEach(series => {
            series.lineStyle = series.lineStyle || {};
            series.lineStyle.width = parseInt(value, 10);
        });
    }
    return currentOptions;
}

/**
 * 更新线条颜色
 * @param {string} value - 颜色值
 * @param {Object} currentOptions - 当前图表配置选项
 * @returns {Object} 更新后的图表配置选项
 */
function updateLineColor(value, currentOptions) {
    if (currentOptions.series && Array.isArray(currentOptions.series)) {
        currentOptions.series.forEach(series => {
            series.lineStyle = series.lineStyle || {};
            series.lineStyle.color = value;
        });
    }
    return currentOptions;
}
